ವಿಧದ ಸುರಕ್ಷತಾ ಮಾದರಿಗಳು: ದೃಢವಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ ರನ್‌ಟೈಮ್ ಮೌಲ್ಯಾಂಕನವನ್ನು ಸಂಯೋಜಿಸುವುದು

ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯ ಜಗತ್ತಿನಲ್ಲಿ, ವಿಧದ ಸುರಕ್ಷತೆಯು ದೃಢವಾದ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವ ಒಂದು ಪ್ರಮುಖ ಅಂಶವಾಗಿದೆ. ಸ್ಥಿರವಾಗಿ ಟೈಪ್ ಮಾಡಿದ ಭಾಷೆಗಳು ಕಂಪೈಲ್-ಟೈಮ್ ವಿಧ ಪರಿಶೀಲನೆಯನ್ನು ನೀಡುತ್ತವೆಯಾದರೂ, ಕ್ರಿಯಾತ್ಮಕ ಡೇಟಾವನ್ನು ವ್ಯವಹರಿಸುವಾಗ ಅಥವಾ ಬಾಹ್ಯ ವ್ಯವಸ್ಥೆಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವಾಗ ರನ್‌ಟೈಮ್ ಮೌಲ್ಯಾಂಕನವು ಅತ್ಯಗತ್ಯವಾಗುತ್ತದೆ. ಈ ಲೇಖನವು ರನ್‌ಟೈಮ್ ಮೌಲ್ಯಾಂಕನವನ್ನು ಸಂಯೋಜಿಸಲು ವಿಧದ ಸುರಕ್ಷತಾ ಮಾದರಿಗಳು ಮತ್ತು ತಂತ್ರಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತದೆ, ದತ್ತಾಂಶ ಸಮಗ್ರತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿನ ಅನಿರೀಕ್ಷಿತ ದೋಷಗಳನ್ನು ತಡೆಯುತ್ತದೆ. ಸ್ಥಿರ ಮತ್ತು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಟೈಪ್ ಮಾಡಿದ ಭಾಷೆಗಳು ಸೇರಿದಂತೆ ವಿವಿಧ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಅನ್ವಯವಾಗುವ ತಂತ್ರಗಳನ್ನು ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ.

ವಿಧದ ಸುರಕ್ಷತೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ವಿಧದ ಸುರಕ್ಷತೆಯು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯು ವಿಧದ ದೋಷಗಳನ್ನು ತಡೆಯುವ ಅಥವಾ ತಗ್ಗಿಸುವ ಮಟ್ಟವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಒಂದು ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಸೂಕ್ತವಲ್ಲದ ವಿಧದ ಮೌಲ್ಯದಲ್ಲಿ ನಡೆಸಿದಾಗ ವಿಧದ ದೋಷ ಸಂಭವಿಸುತ್ತದೆ. ವಿಧದ ಸುರಕ್ಷತೆಯನ್ನು ಕಂಪೈಲ್-ಟೈಮ್‌ನಲ್ಲಿ (ಸ್ಥಿರ ಟೈಪಿಂಗ್) ಅಥವಾ ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ (ಕ್ರಿಯಾತ್ಮಕ ಟೈಪಿಂಗ್) ಜಾರಿಗೊಳಿಸಬಹುದು.

• ಸ್ಥಿರ ಟೈಪಿಂಗ್: ಜಾವಾ, ಸಿ#, ಮತ್ತು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಂತಹ ಭಾಷೆಗಳು ಕಂಪೈಲ್ ಮಾಡುವ ಸಮಯದಲ್ಲಿ ವಿಧ ಪರಿಶೀಲನೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತವೆ. ಇದು ಡೆವಲಪರ್‌ಗಳು ಅಭಿವೃದ್ಧಿ ಚಕ್ರದಲ್ಲಿ ಮೊದಲೇ ವಿಧದ ದೋಷಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ರನ್‌ಟೈಮ್ ವೈಫಲ್ಯಗಳ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಹೆಚ್ಚು ಕ್ರಿಯಾತ್ಮಕ ಡೇಟಾವನ್ನು ವ್ಯವಹರಿಸುವಾಗ ಸ್ಥಿರ ಟೈಪಿಂಗ್ ಕೆಲವೊಮ್ಮೆ ನಿರ್ಬಂಧಿತವಾಗಿರಬಹುದು.
• ಕ್ರಿಯಾತ್ಮಕ ಟೈಪಿಂಗ್: ಪೈಥಾನ್, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್, ಮತ್ತು ರೂಬಿಯಂತಹ ಭಾಷೆಗಳು ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ವಿಧ ಪರಿಶೀಲನೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತವೆ. ಇದು ವಿಭಿನ್ನ ವಿಧಗಳ ಡೇಟಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಹೆಚ್ಚಿನ ನಮ್ಯತೆಯನ್ನು ನೀಡುತ್ತದೆ ಆದರೆ ವಿಧ-ಸಂಬಂಧಿತ ದೋಷಗಳನ್ನು ತಡೆಗಟ್ಟಲು ಎಚ್ಚರಿಕೆಯಿಂದ ರನ್‌ಟೈಮ್ ಮೌಲ್ಯಾಂಕನದ ಅಗತ್ಯವಿದೆ.

ರನ್‌ಟೈಮ್ ಮೌಲ್ಯಾಂಕನದ ಅಗತ್ಯ

ಸ್ಥಿರವಾಗಿ ಟೈಪ್ ಮಾಡಿದ ಭಾಷೆಗಳಲ್ಲಿ ಸಹ, ಬಾಹ್ಯ ಮೂಲಗಳಿಂದ ಡೇಟಾ ಬಂದಾಗ ಅಥವಾ ಕ್ರಿಯಾತ್ಮಕ ಕುಶಲತೆಗೆ ಒಳಪಟ್ಟಾಗ ರನ್‌ಟೈಮ್ ಮೌಲ್ಯಾಂಕನವು ಸಾಮಾನ್ಯವಾಗಿ ಅಗತ್ಯವಾಗಿರುತ್ತದೆ. ಸಾಮಾನ್ಯ ಸನ್ನಿವೇಶಗಳು ಒಳಗೊಂಡಿವೆ:

• ಬಾಹ್ಯ API ಗಳು: ಬಾಹ್ಯ API ಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವಾಗ, ಹಿಂತಿರುಗಿಸಿದ ಡೇಟಾ ಯಾವಾಗಲೂ ನಿರೀಕ್ಷಿತ ವಿಧಗಳಿಗೆ ಅನುಗುಣವಾಗಿರುವುದಿಲ್ಲ. ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಬಳಸಲು ಡೇಟಾ ಸುರಕ್ಷಿತವಾಗಿದೆ ಎಂದು ರನ್‌ಟೈಮ್ ಮೌಲ್ಯಾಂಕನವು ಖಚಿತಪಡಿಸುತ್ತದೆ.
• ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್: ಬಳಕೆದಾರರು ನಮೂದಿಸಿದ ಡೇಟಾವು ಊಹಿಸಲಾಗದಂತಿರಬಹುದು ಮತ್ತು ಯಾವಾಗಲೂ ನಿರೀಕ್ಷಿತ ಸ್ವರೂಪಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ. ಅಮಾನ್ಯ ಡೇಟಾ ಅಪ್ಲಿಕೇಶನ್ ಸ್ಥಿತಿಯನ್ನು ಭ್ರಷ್ಟಗೊಳಿಸುವುದನ್ನು ತಡೆಯಲು ರನ್‌ಟೈಮ್ ಮೌಲ್ಯಾಂಕನವು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
• ಡೇಟಾಬೇಸ್ ಪರಸ್ಪರ ಕ್ರಿಯೆಗಳು: ಡೇಟಾಬೇಸ್‌ಗಳಿಂದ ಹಿಂಪಡೆದ ಡೇಟಾವು ವ್ಯತ್ಯಾಸಗಳನ್ನು ಹೊಂದಿರಬಹುದು ಅಥವಾ ಸ್ಕೀಮಾ ಬದಲಾವಣೆಗಳಿಗೆ ಒಳಪಟ್ಟಿರಬಹುದು. ಡೇಟಾವು ಅಪ್ಲಿಕೇಶನ್ ತರ್ಕದೊಂದಿಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆಯೇ ಎಂದು ರನ್‌ಟೈಮ್ ಮೌಲ್ಯಾಂಕನವು ಖಚಿತಪಡಿಸುತ್ತದೆ.
• ಡಿಸೀರಿಯಲೈಸೇಶನ್: JSON ಅಥವಾ XML ನಂತಹ ಸ್ವರೂಪಗಳಿಂದ ಡೇಟಾವನ್ನು ಡಿಸೀರಿಯಲೈಸ್ ಮಾಡುವಾಗ, ಪರಿಣಾಮವಾಗಿ ಬರುವ ವಸ್ತುಗಳು ನಿರೀಕ್ಷಿತ ವಿಧಗಳು ಮತ್ತು ರಚನೆಗೆ ಅನುಗುಣವಾಗಿವೆಯೇ ಎಂದು ಮೌಲ್ಯಾಂಕನ ಮಾಡುವುದು ಬಹಳ ಮುಖ್ಯ.
• ಸಂರಚನಾ ಕಡತಗಳು: ಸಂರಚನಾ ಕಡತಗಳು ಹೆಚ್ಚಾಗಿ ಅಪ್ಲಿಕೇಶನ್‌ನ ನಡವಳಿಕೆಯನ್ನು ಪರಿಣಾಮ ಬೀರುವ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ. ಈ ಸೆಟ್ಟಿಂಗ್‌ಗಳು ಮಾನ್ಯವಾಗಿವೆ ಮತ್ತು ಸ್ಥಿರವಾಗಿವೆ ಎಂದು ರನ್‌ಟೈಮ್ ಮೌಲ್ಯಾಂಕನವು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ರನ್‌ಟೈಮ್ ಮೌಲ್ಯಾಂಕನಕ್ಕಾಗಿ ವಿಧದ ಸುರಕ್ಷತಾ ಮಾದರಿಗಳು

ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ರನ್‌ಟೈಮ್ ಮೌಲ್ಯಾಂಕನವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಸಂಯೋಜಿಸಲು ಹಲವಾರು ಮಾದರಿಗಳು ಮತ್ತು ತಂತ್ರಗಳನ್ನು ಬಳಸಬಹುದು.

1. ವಿಧದ ಪ್ರತಿಪಾದನೆಗಳು ಮತ್ತು ಎರಕಹೊಯ್ದ

ವಿಧದ ಪ್ರತಿಪಾದನೆಗಳು ಮತ್ತು ಎರಕಹೊಯ್ದವು ಒಂದು ಮೌಲ್ಯವು ನಿರ್ದಿಷ್ಟ ವಿಧವನ್ನು ಹೊಂದಿದೆ ಎಂದು ಕಂಪೈಲರ್‌ಗೆ ಸ್ಪಷ್ಟವಾಗಿ ತಿಳಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಅವುಗಳನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಬಳಸಬೇಕು, ಏಕೆಂದರೆ ಅವು ವಿಧ ಪರಿಶೀಲನೆಯನ್ನು ಬೈಪಾಸ್ ಮಾಡಬಹುದು ಮತ್ತು ಪ್ರತಿಪಾದಿಸಿದ ವಿಧವು ತಪ್ಪಾಗಿದ್ದರೆ ರನ್‌ಟೈಮ್ ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಉದಾಹರಣೆ:

function processData(data: any): string {
  if (typeof data === 'string') {
    return data.toUpperCase();
  } else if (typeof data === 'number') {
    return data.toString();
  } else {
    throw new Error('ಅಮಾನ್ಯ ದತ್ತಾಂಶ ವಿಧ');
  }
}

let input: any = 42;
let result = processData(input);
console.log(result); // ಔಟ್ಪುಟ್: 42

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, `processData` ಕಾರ್ಯವು `any` ವಿಧವನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಅಂದರೆ ಅದು ಯಾವುದೇ ರೀತಿಯ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಬಹುದು. ಕಾರ್ಯದ ಒಳಗೆ, ಡೇಟಾದ ನಿಜವಾದ ವಿಧವನ್ನು ಪರಿಶೀಲಿಸಲು ಮತ್ತು ಸೂಕ್ತ ಕ್ರಮಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ನಾವು `typeof` ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ಇದು ರನ್‌ಟೈಮ್ ವಿಧ ಪರಿಶೀಲನೆಯ ಒಂದು ರೂಪವಾಗಿದೆ. `input` ಯಾವಾಗಲೂ ಸಂಖ್ಯೆಯಾಗಿರುತ್ತದೆ ಎಂದು ನಮಗೆ ತಿಳಿದಿದ್ದರೆ, ನಾವು `(input as number).toString()` ನಂತಹ ವಿಧದ ಪ್ರತಿಪಾದನೆಯನ್ನು ಬಳಸಬಹುದು, ಆದರೆ ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ವಿಧದ ಸುರಕ್ಷತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು `typeof` ನೊಂದಿಗೆ ಸ್ಪಷ್ಟವಾದ ವಿಧ ಪರಿಶೀಲನೆಯನ್ನು ಬಳಸುವುದು ಸಾಮಾನ್ಯವಾಗಿ ಉತ್ತಮ.

2. ಸ್ಕೀಮಾ ಮೌಲ್ಯಾಂಕನ

ಸ್ಕೀಮಾ ಮೌಲ್ಯಾಂಕನವು ದತ್ತಾಂಶದ ನಿರೀಕ್ಷಿತ ರಚನೆ ಮತ್ತು ವಿಧಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಸ್ಕೀಮಾವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ, ಡೇಟಾವು ನಿರೀಕ್ಷಿತ ಸ್ವರೂಪಕ್ಕೆ ಅನುಗುಣವಾಗಿದೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಈ ಸ್ಕೀಮಾದ ವಿರುದ್ಧ ಮೌಲ್ಯಾಂಕನ ಮಾಡಲಾಗುತ್ತದೆ. JSON ಸ್ಕೀಮಾ, Joi (ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್), ಮತ್ತು Cerberus (ಪೈಥಾನ್) ನಂತಹ ಲೈಬ್ರರಿಗಳನ್ನು ಸ್ಕೀಮಾ ಮೌಲ್ಯಾಂಕನಕ್ಕಾಗಿ ಬಳಸಬಹುದು.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಉದಾಹರಣೆ (Joi ಬಳಸಿ):

const Joi = require('joi');

const schema = Joi.object({
  name: Joi.string().required(),
  age: Joi.number().integer().min(0).required(),
  email: Joi.string().email(),
});

function validateUser(user) {
  const { error, value } = schema.validate(user);
  if (error) {
    throw new Error(`ಮೌಲ್ಯಾಂಕನದ ದೋಷ: ${error.message}`);
  }
  return value;
}

const validUser = { name: 'Alice', age: 30, email: 'alice@example.com' };
const invalidUser = { name: 'Bob', age: -5, email: 'bob' };

try {
  const validatedUser = validateUser(validUser);
  console.log('ಮಾನ್ಯ ಬಳಕೆದಾರ:', validatedUser);

  validateUser(invalidUser); // ಇದು ದೋಷವನ್ನು ಎಸೆಯುತ್ತದೆ
} catch (error) {
  console.error(error.message);
}

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಬಳಕೆದಾರ ವಸ್ತುಗಳಿಗಾಗಿ ಸ್ಕೀಮಾವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು Joi ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. `validateUser` ಕಾರ್ಯವು ಸ್ಕೀಮಾದ ವಿರುದ್ಧ ಇನ್‌ಪುಟ್ ಅನ್ನು ಮೌಲ್ಯಾಂಕನ ಮಾಡುತ್ತದೆ ಮತ್ತು ಡೇಟಾ ಅಮಾನ್ಯವಾಗಿದ್ದರೆ ದೋಷವನ್ನು ಎಸೆಯುತ್ತದೆ. ಈ ಮಾದರಿಯು ವಿಶೇಷವಾಗಿ ಬಾಹ್ಯ API ಗಳು ಅಥವಾ ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್‌ನಿಂದ ಡೇಟಾವನ್ನು ವ್ಯವಹರಿಸುವಾಗ ಉಪಯುಕ್ತವಾಗಿದೆ, ಅಲ್ಲಿ ರಚನೆ ಮತ್ತು ವಿಧಗಳನ್ನು ಖಾತರಿಪಡಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

3. ಮೌಲ್ಯಾಂಕನದೊಂದಿಗೆ ಡೇಟಾ ವರ್ಗಾವಣೆ ವಸ್ತುಗಳು (DTOs)

ಡೇಟಾ ವರ್ಗಾವಣೆ ವಸ್ತುಗಳು (DTOs) ಅಪ್ಲಿಕೇಶನ್‌ನ ಪದರಗಳ ನಡುವೆ ಡೇಟಾವನ್ನು ವರ್ಗಾಯಿಸಲು ಬಳಸುವ ಸರಳ ವಸ್ತುಗಳಾಗಿವೆ. DTO ಗಳಿಗೆ ಮೌಲ್ಯಾಂಕನ ತರ್ಕವನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ, ಅಪ್ಲಿಕೇಶನ್‌ನ ಇತರ ಭಾಗಗಳಿಂದ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಮೊದಲು ಡೇಟಾವು ಮಾನ್ಯವಾಗಿದೆ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು.

ಜಾವಾ ಉದಾಹರಣೆ:

import javax.validation.constraints.*;

public class UserDTO {

  @NotBlank(message = "ಹೆಸರು ಖಾಲಿ ಇರಬಾರದು")
  private String name;

  @Min(value = 0, message = "ವಯಸ್ಸು ಋಣಾತ್ಮಕವಾಗಿರಬಾರದು")
  private int age;

  @Email(message = "ಅಮಾನ್ಯ ಇಮೇಲ್ ಸ್ವರೂಪ")
  private String email;

  public UserDTO(String name, int age, String email) {
    this.name = name;
    this.age = age;
    this.email = email;
  }

  public String getName() {
    return name;
  }

  public int getAge() {
    return age;
  }

  public String getEmail() {
    return email;
  }

  @Override
  public String toString() {
    return "UserDTO{" +
        "name='" + name + '\'' +
        ", age=" + age +
        ", email='" + email + '\'' +
        '}';
  }
}

// ಬಳಕೆ (ಬೀನ್ ಮೌಲ್ಯಾಂಕನ API ನಂತಹ ಮೌಲ್ಯಾಂಕನ ಚೌಕಟ್ಟಿನೊಂದಿಗೆ)

import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import java.util.Set;
import javax.validation.ConstraintViolation;

public class Main {
    public static void main(String[] args) {
        UserDTO user = new UserDTO("", -10, "invalid-email");

        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        Validator validator = factory.getValidator();

        Set> violations = validator.validate(user);

        if (!violations.isEmpty()) {
            for (ConstraintViolation violation : violations) {
                System.err.println(violation.getMessage());
            }
        } else {
            System.out.println("UserDTO ಮಾನ್ಯವಾಗಿದೆ: " + user);
        }
    }
}

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, Java ನ ಬೀನ್ ಮೌಲ್ಯಾಂಕನ API ಅನ್ನು `UserDTO` ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ನಿರ್ಬಂಧಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ನಂತರ `Validator` ಈ ನಿರ್ಬಂಧಗಳ ವಿರುದ್ಧ DTO ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಯಾವುದೇ ಉಲ್ಲಂಘನೆಗಳನ್ನು ವರದಿ ಮಾಡುತ್ತದೆ. ಈ ವಿಧಾನವು ಪದರಗಳ ನಡುವೆ ವರ್ಗಾಯಿಸಲ್ಪಡುವ ಡೇಟಾವು ಮಾನ್ಯವಾಗಿದೆ ಮತ್ತು ಸ್ಥಿರವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

4. ಕಸ್ಟಮ್ ವಿಧದ ಗಾರ್ಡ್‌ಗಳು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ಕಸ್ಟಮ್ ವಿಧದ ಗಾರ್ಡ್‌ಗಳು ಷರತ್ತುಬದ್ಧ ಬ್ಲಾಕ್‌ನಲ್ಲಿ ವೇರಿಯೇಬಲ್‌ನ ವಿಧವನ್ನು ಕಿರಿದಾಗಿಸುವ ಕಾರ್ಯಗಳಾಗಿವೆ. ಇದು ಸಂಸ್ಕರಿಸಿದ ವಿಧದ ಆಧಾರದ ಮೇಲೆ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಉದಾಹರಣೆ:

interface Circle {
  kind: 'circle';
  radius: number;
}

interface Square {
  kind: 'square';
  side: number;
}

type Shape = Circle | Square;

function isCircle(shape: Shape): shape is Circle {
  return shape.kind === 'circle';
}

function getArea(shape: Shape): number {
  if (isCircle(shape)) {
    return Math.PI * shape.radius * shape.radius;  // ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಆಕಾರವು ವೃತ್ತವಾಗಿದೆ ಎಂದು ತಿಳಿದಿದೆ ಇಲ್ಲಿ
  } else {
    return shape.side * shape.side; // ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಆಕಾರವು ಚೌಕವಾಗಿದೆ ಎಂದು ತಿಳಿದಿದೆ ಇಲ್ಲಿ
  }
}

const myCircle: Shape = { kind: 'circle', radius: 5 };
const mySquare: Shape = { kind: 'square', side: 4 };

console.log('ವೃತ್ತದ ವಿಸ್ತೀರ್ಣ:', getArea(myCircle)); // ಔಟ್ಪುಟ್: ವೃತ್ತದ ವಿಸ್ತೀರ್ಣ: 78.53981633974483
console.log('ಚೌಕದ ವಿಸ್ತೀರ್ಣ:', getArea(mySquare)); // ಔಟ್ಪುಟ್: ಚೌಕದ ವಿಸ್ತೀರ್ಣ: 16

`isCircle` ಕಾರ್ಯವು ಕಸ್ಟಮ್ ವಿಧದ ಗಾರ್ಡ್ ಆಗಿದೆ. ಅದು `true` ಅನ್ನು ಹಿಂತಿರುಗಿಸಿದಾಗ, `if` ಬ್ಲಾಕ್‌ನಲ್ಲಿರುವ `shape` ವೇರಿಯೇಬಲ್ `Circle` ವಿಧವಾಗಿದೆ ಎಂದು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ತಿಳಿದಿದೆ. ಇದು ವಿಧದ ದೋಷವಿಲ್ಲದೆ `radius` ಆಸ್ತಿಯನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಪ್ರವೇಶಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಯೂನಿಯನ್ ವಿಧಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಮತ್ತು ರನ್‌ಟೈಮ್ ಷರತ್ತುಗಳ ಆಧಾರದ ಮೇಲೆ ವಿಧದ ಸುರಕ್ಷತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಕಸ್ಟಮ್ ವಿಧದ ಗಾರ್ಡ್‌ಗಳು ಉಪಯುಕ್ತವಾಗಿವೆ.

5. ಬೀಜಗಣಿತ ದತ್ತಾಂಶ ವಿಧಗಳೊಂದಿಗೆ (ADTs) ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್

ವಿವಿಧ ಡೇಟಾ ರೂಪಾಂತರಗಳನ್ನು ನಿರ್ವಹಿಸಲು ವಿಧ-ಸುರಕ್ಷಿತ ಮತ್ತು ಅಭಿವ್ಯಕ್ತಿಶೀಲ ಕೋಡ್ ಅನ್ನು ರಚಿಸಲು ಬೀಜಗಣಿತ ದತ್ತಾಂಶ ವಿಧಗಳನ್ನು (ADTs) ಮತ್ತು ಮಾದರಿ ಹೊಂದಾಣಿಕೆಯನ್ನು ಬಳಸಬಹುದು. ಹ್ಯಾಸ್ಕೆಲ್, ಸ್ಕೇಲಾ ಮತ್ತು ರಸ್ಟ್‌ನಂತಹ ಭಾಷೆಗಳು ADT ಗಳಿಗೆ ಅಂತರ್ನಿರ್ಮಿತ ಬೆಂಬಲವನ್ನು ನೀಡುತ್ತವೆ, ಆದರೆ ಅವುಗಳನ್ನು ಇತರ ಭಾಷೆಗಳಲ್ಲಿಯೂ ಅನುಕರಿಸಬಹುದು.

ಸ್ಕೇಲಾ ಉದಾಹರಣೆ:

sealed trait Result[+A]
case class Success[A](value: A) extends Result[A]
case class Failure(message: String) extends Result[Nothing]

object Result {
  def parseInt(s: String): Result[Int] = {
    try {
      Success(s.toInt)
    } catch {
      case e: NumberFormatException => Failure("ಅಮಾನ್ಯ ಪೂರ್ಣಾಂಕ ಸ್ವರೂಪ")
    }
  }
}

val numberResult: Result[Int] = Result.parseInt("42")
val invalidResult: Result[Int] = Result.parseInt("abc")

numberResult match {
  case Success(value) => println(s"ಪಾರ್ಸ್ ಮಾಡಿದ ಸಂಖ್ಯೆ: $value") // ಔಟ್ಪುಟ್: ಪಾರ್ಸ್ ಮಾಡಿದ ಸಂಖ್ಯೆ: 42
  case Failure(message) => println(s"ದೋಷ: $message")
}

invalidResult match {
  case Success(value) => println(s"ಪಾರ್ಸ್ ಮಾಡಿದ ಸಂಖ್ಯೆ: $value")
  case Failure(message) => println(s"ದೋಷ: $message") // ಔಟ್ಪುಟ್: ದೋಷ: ಅಮಾನ್ಯ ಪೂರ್ಣಾಂಕ ಸ್ವರೂಪ
}

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, `Result` ಎರಡು ರೂಪಾಂತರಗಳನ್ನು ಹೊಂದಿರುವ ADT ಆಗಿದೆ: `Success` ಮತ್ತು `Failure`. `parseInt` ಕಾರ್ಯವು `Result[Int]` ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇದು ಪಾರ್ಸಿಂಗ್ ಯಶಸ್ವಿಯಾಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ಸೂಚಿಸುತ್ತದೆ. `Result` ನ ವಿವಿಧ ರೂಪಾಂತರಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಮಾದರಿ ಹೊಂದಾಣಿಕೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಕೋಡ್ ವಿಧ-ಸುರಕ್ಷಿತವಾಗಿದೆ ಮತ್ತು ದೋಷಗಳನ್ನು ಸಲೀಸಾಗಿ ನಿಭಾಯಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಈ ಮಾದರಿಯು ವಿಫಲಗೊಳ್ಳುವ ಸಾಧ್ಯತೆಯಿರುವ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ವ್ಯವಹರಿಸಲು ನಿರ್ದಿಷ್ಟವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ, ಯಶಸ್ಸು ಮತ್ತು ವೈಫಲ್ಯದ ಸಂದರ್ಭಗಳನ್ನು ನಿಭಾಯಿಸಲು ಸ್ಪಷ್ಟ ಮತ್ತು ಸಂಕ್ಷಿಪ್ತ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.

6. ಟ್ರೈ-ಕ್ಯಾಚ್ ಬ್ಲಾಕ್‌ಗಳು ಮತ್ತು ಎಕ್ಸೆಪ್ಶನ್ ನಿರ್ವಹಣೆ

ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಹೇಳುವುದಾದರೆ ವಿಧದ ಸುರಕ್ಷತಾ ಮಾದರಿಯಲ್ಲದಿದ್ದರೂ, ವಿಧ-ಸಂಬಂಧಿತ ಸಮಸ್ಯೆಗಳಿಂದ ಉಂಟಾಗುವ ರನ್‌ಟೈಮ್ ದೋಷಗಳನ್ನು ವ್ಯವಹರಿಸಲು ಸರಿಯಾದ ಎಕ್ಸೆಪ್ಶನ್ ನಿರ್ವಹಣೆ ಬಹಳ ಮುಖ್ಯ. ಸಂಭಾವ್ಯವಾಗಿ ಸಮಸ್ಯಾತ್ಮಕ ಕೋಡ್ ಅನ್ನು ಟ್ರೈ-ಕ್ಯಾಚ್ ಬ್ಲಾಕ್‌ಗಳಲ್ಲಿ ಸುತ್ತುವರಿಯುವುದು ವಿನಾಯಿತಿಗಳನ್ನು ಸಲೀಸಾಗಿ ನಿರ್ವಹಿಸಲು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಕ್ರ್ಯಾಶ್ ಆಗುವುದನ್ನು ತಡೆಯಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಪೈಥಾನ್ ಉದಾಹರಣೆ:

def divide(x, y):
    try:
        result = x / y
        return result
    except TypeError:
        print("ದೋಷ: ಎರಡೂ ಇನ್‌ಪುಟ್‌ಗಳು ಸಂಖ್ಯೆಗಳಾಗಿರಬೇಕು.")
        return None
    except ZeroDivisionError:
        print("ದೋಷ: ಸೊನ್ನೆಯಿಂದ ಭಾಗಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.")
        return None

print(divide(10, 2))  # ಔಟ್ಪುಟ್: 5.0
print(divide(10, '2')) # ಔಟ್ಪುಟ್: ದೋಷ: ಎರಡೂ ಇನ್‌ಪುಟ್‌ಗಳು ಸಂಖ್ಯೆಗಳಾಗಿರಬೇಕು.
                         #         None
print(divide(10, 0))  # ಔಟ್ಪುಟ್: ದೋಷ: ಸೊನ್ನೆಯಿಂದ ಭಾಗಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.
                         #         None

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, `divide` ಕಾರ್ಯವು ಸಂಭಾವ್ಯ `TypeError` ಮತ್ತು `ZeroDivisionError` ವಿನಾಯಿತಿಗಳನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ. ಅಮಾನ್ಯ ಇನ್‌ಪುಟ್‌ಗಳನ್ನು ಒದಗಿಸಿದಾಗ ಇದು ಅಪ್ಲಿಕೇಶನ್ ಕ್ರ್ಯಾಶ್ ಆಗುವುದನ್ನು ತಡೆಯುತ್ತದೆ. ವಿನಾಯಿತಿ ನಿರ್ವಹಣೆಯು ವಿಧದ ಸುರಕ್ಷತೆಯನ್ನು ಖಾತರಿಪಡಿಸದಿದ್ದರೂ, ರನ್‌ಟೈಮ್ ದೋಷಗಳನ್ನು ಸಲೀಸಾಗಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ ಎಂದು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಅನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆಯನ್ನು ತಡೆಯುತ್ತದೆ.

ರನ್‌ಟೈಮ್ ಮೌಲ್ಯಾಂಕನವನ್ನು ಸಂಯೋಜಿಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

• ಬೇಗ ಮತ್ತು ಆಗಾಗ್ಗೆ ಮೌಲ್ಯಾಂಕನ ಮಾಡಿ: ಅಮಾನ್ಯ ಡೇಟಾವು ಅಪ್ಲಿಕೇಶನ್ ಮೂಲಕ ಹರಡುವುದನ್ನು ತಡೆಯಲು ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಪೈಪ್‌ಲೈನ್‌ನಲ್ಲಿ ಸಾಧ್ಯವಾದಷ್ಟು ಬೇಗ ಮೌಲ್ಯಾಂಕನವನ್ನು ನಿರ್ವಹಿಸಿ.
• ಮಾಹಿತಿಯುಕ್ತ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಒದಗಿಸಿ: ಮೌಲ್ಯಾಂಕನ ವಿಫಲವಾದಾಗ, ಡೆವಲಪರ್‌ಗಳು ಸಮಸ್ಯೆಯನ್ನು ತ್ವರಿತವಾಗಿ ಗುರುತಿಸಲು ಮತ್ತು ಸರಿಪಡಿಸಲು ಸಹಾಯ ಮಾಡುವ ಸ್ಪಷ್ಟ ಮತ್ತು ಮಾಹಿತಿಯುಕ್ತ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಒದಗಿಸಿ.
• ಸ್ಥಿರವಾದ ಮೌಲ್ಯಾಂಕನ ತಂತ್ರವನ್ನು ಬಳಸಿ: ಡೇಟಾವನ್ನು ಏಕರೂಪದ ಮತ್ತು ಊಹಿಸಬಹುದಾದ ರೀತಿಯಲ್ಲಿ ಮೌಲ್ಯಾಂಕನ ಮಾಡಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಅಪ್ಲಿಕೇಶನ್‌ನಾದ್ಯಂತ ಸ್ಥಿರವಾದ ಮೌಲ್ಯಾಂಕನ ತಂತ್ರವನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ.
• ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮಗಳನ್ನು ಪರಿಗಣಿಸಿ: ರನ್‌ಟೈಮ್ ಮೌಲ್ಯಾಂಕನವು ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮಗಳನ್ನು ಬೀರಬಹುದು, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ವ್ಯವಹರಿಸುವಾಗ. ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಮೌಲ್ಯಾಂಕನ ತರ್ಕವನ್ನು ಉತ್ತಮಗೊಳಿಸಿ.
• ನಿಮ್ಮ ಮೌಲ್ಯಾಂಕನ ತರ್ಕವನ್ನು ಪರೀಕ್ಷಿಸಿ: ಅಮಾನ್ಯ ಡೇಟಾವನ್ನು ಸರಿಯಾಗಿ ಗುರುತಿಸುತ್ತದೆ ಮತ್ತು ಎಡ್ಜ್ ಕೇಸ್‌ಗಳನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಿಮ್ಮ ಮೌಲ್ಯಾಂಕನ ತರ್ಕವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಿ.
• ನಿಮ್ಮ ಮೌಲ್ಯಾಂಕನ ನಿಯಮಗಳನ್ನು ದಾಖಲಿಸಿ: ಡೆವಲಪರ್‌ಗಳು ನಿರೀಕ್ಷಿತ ಡೇಟಾ ಸ್ವರೂಪ ಮತ್ತು ನಿರ್ಬಂಧಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಬಳಸಲಾದ ಮೌಲ್ಯಾಂಕನ ನಿಯಮಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ದಾಖಲಿಸಿ.
• ಕ್ಲೈಂಟ್-ಸೈಡ್ ಮೌಲ್ಯಾಂಕನವನ್ನು ಮಾತ್ರ ಅವಲಂಬಿಸಬೇಡಿ: ಕ್ಲೈಂಟ್-ಸೈಡ್ ಮೌಲ್ಯಾಂಕನವನ್ನು ಸಹ ಕಾರ್ಯಗತಗೊಳಿಸಿದರೂ, ಸರ್ವರ್-ಸೈಡ್‌ನಲ್ಲಿ ಯಾವಾಗಲೂ ಡೇಟಾವನ್ನು ಮೌಲ್ಯಾಂಕನ ಮಾಡಿ. ಕ್ಲೈಂಟ್-ಸೈಡ್ ಮೌಲ್ಯಾಂಕನವನ್ನು ಬೈಪಾಸ್ ಮಾಡಬಹುದು, ಆದ್ದರಿಂದ ಸರ್ವರ್-ಸೈಡ್ ಮೌಲ್ಯಾಂಕನವು ಭದ್ರತೆ ಮತ್ತು ಡೇಟಾ ಸಮಗ್ರತೆಗೆ ಅತ್ಯಗತ್ಯ.

ತೀರ್ಮಾನ

ವಿಶೇಷವಾಗಿ ಕ್ರಿಯಾತ್ಮಕ ಡೇಟಾವನ್ನು ವ್ಯವಹರಿಸುವಾಗ ಅಥವಾ ಬಾಹ್ಯ ವ್ಯವಸ್ಥೆಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವಾಗ ದೃಢವಾದ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ರನ್‌ಟೈಮ್ ಮೌಲ್ಯಾಂಕನವನ್ನು ಸಂಯೋಜಿಸುವುದು ಬಹಳ ಮುಖ್ಯ. ವಿಧದ ಪ್ರತಿಪಾದನೆಗಳು, ಸ್ಕೀಮಾ ಮೌಲ್ಯಾಂಕನ, ಮೌಲ್ಯಾಂಕನದೊಂದಿಗೆ DTO ಗಳು, ಕಸ್ಟಮ್ ವಿಧದ ಗಾರ್ಡ್‌ಗಳು, ADT ಗಳು ಮತ್ತು ಸರಿಯಾದ ವಿನಾಯಿತಿ ನಿರ್ವಹಣೆಯಂತಹ ವಿಧದ ಸುರಕ್ಷತಾ ಮಾದರಿಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ, ನೀವು ಡೇಟಾ ಸಮಗ್ರತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು ಮತ್ತು ಅನಿರೀಕ್ಷಿತ ದೋಷಗಳನ್ನು ತಡೆಯಬಹುದು. ಬೇಗ ಮತ್ತು ಆಗಾಗ್ಗೆ ಮೌಲ್ಯಾಂಕನ ಮಾಡಲು, ಮಾಹಿತಿಯುಕ್ತ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಒದಗಿಸಲು ಮತ್ತು ಸ್ಥಿರವಾದ ಮೌಲ್ಯಾಂಕನ ತಂತ್ರವನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಲು ನೆನಪಿಡಿ. ಈ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ, ನೀವು ಅಮಾನ್ಯ ಡೇಟಾಗೆ ಸ್ಥಿತಿಸ್ಥಾಪಕತ್ವ ಹೊಂದಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು ಮತ್ತು ಉತ್ತಮ ಬಳಕೆದಾರ ಅನುಭವವನ್ನು ಒದಗಿಸಬಹುದು.

ಈ ತಂತ್ರಗಳನ್ನು ನಿಮ್ಮ ಅಭಿವೃದ್ಧಿ ಹರಿವಿನಲ್ಲಿ ಸೇರಿಸುವ ಮೂಲಕ, ನಿಮ್ಮ ಸಾಫ್ಟ್‌ವೇರ್‌ನ ಒಟ್ಟಾರೆ ಗುಣಮಟ್ಟ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ನೀವು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸಬಹುದು, ಇದು ಅನಿರೀಕ್ಷಿತ ದೋಷಗಳಿಗೆ ಹೆಚ್ಚು ನಿರೋಧಕವಾಗಿದೆ ಮತ್ತು ಡೇಟಾ ಸಮಗ್ರತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. ವಿಧದ ಸುರಕ್ಷತೆ ಮತ್ತು ರನ್‌ಟೈಮ್ ಮೌಲ್ಯಾಂಕನಕ್ಕೆ ಈ ಪೂರ್ವಭಾವಿ ವಿಧಾನವು ಇಂದಿನ ಕ್ರಿಯಾತ್ಮಕ ಸಾಫ್ಟ್‌ವೇರ್ ಭೂದೃಶ್ಯದಲ್ಲಿ ದೃಢವಾದ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಅತ್ಯಗತ್ಯ.